package com.yunkeji.common.utils.call;

import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.http.HttpUtil;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;

import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.green.model.v20180509.ImageSyncScanRequest;
import com.aliyuncs.http.FormatType;
import com.aliyuncs.http.HttpResponse;
import com.aliyuncs.http.MethodType;
import com.aliyuncs.http.ProtocolType;
import com.aliyuncs.profile.DefaultProfile;
import com.tencentcloudapi.common.AbstractModel;
import com.tencentcloudapi.common.Credential;
import com.tencentcloudapi.common.exception.TencentCloudSDKException;
import com.tencentcloudapi.common.profile.ClientProfile;
import com.tencentcloudapi.common.profile.HttpProfile;
import com.tencentcloudapi.trtc.v20190722.TrtcClient;
import com.tencentcloudapi.trtc.v20190722.models.*;
import com.yunkeji.common.exception.AppServiceException;

import lombok.Data;
import lombok.SneakyThrows;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;

import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.*;
import java.util.zip.Deflater;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

@Slf4j
public class TencentRTCUtils {

    private static TrtcClient TRTC_CLIENT;
    private static IAcsClient IACS_CLIENT;
    private static Cos COS;
    private static Trtc TRTC;
    private static Yitu YITU;
    private static final String HMAC_SHA256_ALGORITHM = "HmacSHA256";
    private static String RECORD_BASE_PATH = "record";

    public static void initTrtc(Trtc trtc) {
        TRTC = trtc;
        Credential cred = new Credential(TRTC.getSecretId(), TRTC.getSecretKey());
        // 实例化一个http选项，可选的，没有特殊需求可以跳过
        HttpProfile httpProfile = new HttpProfile();
        httpProfile.setEndpoint(TRTC.getEndpoint());
        // 实例化一个client选项，可选的，没有特殊需求可以跳过
        ClientProfile clientProfile = new ClientProfile();
        clientProfile.setHttpProfile(httpProfile);
        // 实例化要请求产品的client对象,clientProfile是可选的
        TRTC_CLIENT = new TrtcClient(cred, TRTC.getRegion(), clientProfile);
    }

    public static void initCOS(Cos cos) {
        COS = cos;
    }

    public static void initYitu(Yitu yitu) {
        YITU = yitu;
    }

    /**
     * 初始化鉴黄客户端
     *
     * @author 老张
     */
    public static void initIacsClient(SnapCheck snapCheck) {
        DefaultProfile profile =
                DefaultProfile.getProfile(
                        snapCheck.getRegion(),
                        snapCheck.getAccessKeyId(),
                        snapCheck.getAccessKeySecret());
        DefaultProfile.addEndpoint(snapCheck.getRegion(), "Green", snapCheck.getEndpoint());
        IACS_CLIENT = new DefaultAcsClient(profile);
    }

    /**
     * 停止录音实时检测
     *
     * @author 老张
     */
    public static void stopCheckVoice(String requestId) {
        long timestamp = System.currentTimeMillis() / 1000L;
        String signKey = YITU.getAccessId() + timestamp;
        String signature = calculateRFC2104HMAC(signKey, YITU.getAccessKey());

        cn.hutool.http.HttpResponse execute =
                HttpUtil.createPost(YITU.getDomain() + "/v1/antispam/streamclose")
                        .header("x-dev-id", YITU.getAccessId())
                        .header("x-request-send-timestamp", String.valueOf(timestamp))
                        .header("x-signature", signature)
                        .body(JSONUtil.createObj().set("requestId", requestId).toString())
                        .execute();
        int status = execute.getStatus();
        if (status == 200) {
            String body = execute.body();
            JSONObject entries = JSONUtil.parseObj(body);
            log.info("语音实时监测任务停止成功:{}", entries);
        } else {
            String s = execute.toString();
            log.info("语音实时停止失败:{},请求内容:{}", execute.getStatus(), s);
        }
    }

    /**
     * 语音实时检测
     *
     * @author 老张
     */
    public static String startCheckVoice(String resUrl, String roomId) {
        long timestamp = System.currentTimeMillis() / 1000L;
        String signKey = YITU.getAccessId() + timestamp;
        String signature = calculateRFC2104HMAC(signKey, YITU.getAccessKey());

        String checkUid = RandomUtil.randomString(8);
        String req =
                JSONUtil.createObj()
                        .set("appId", YITU.getAppId())
                        .set("callback", YITU.getCallback())
                        .set(
                                "trtcParam",
                                JSONUtil.createObj()
                                        .set("userId", checkUid)
                                        .set("userSig", genUserSig(checkUid, 60))
                                        .set("sdkAppId", TRTC.appid)
                                        .set("trtcRoomType", "TRTC_STRING_ROOM")
                                        .set("trtcStringRoomId", roomId))
                        .set(
                                "data",
                                JSONUtil.createObj()
                                        .set("returnBeforeText", true)
                                        .set("returnBeforeAudio", true)
                                        .set("audioId", roomId))
                        .set(
                                "clientInfo",
                                JSONUtil.createObj().set("roomId", roomId).set("userId", checkUid))
                        .toString();
        cn.hutool.http.HttpResponse execute =
                HttpUtil.createPost(YITU.getDomain() + "/v1/antispam/streamscan")
                        .header("x-dev-id", YITU.getAccessId())
                        .header("x-request-send-timestamp", String.valueOf(timestamp))
                        .header("x-signature", signature)
                        .body(req)
                        .execute();
        int status = execute.getStatus();
        log.info("语音实时监测任务请求参数：{}", req);
        if (status == 200) {
            String body = execute.body();
            JSONObject entries = JSONUtil.parseObj(body);
            log.info("语音实时监测任务提交成功:{}", entries);
            return entries.getStr("requestId");
        } else {
            String s = execute.toString();
            log.info("语音实时监测失败:{},请求内容:{}", execute.getStatus(), s);
            return StrUtil.EMPTY;
        }
    }

    /**
     * 鉴黄
     *
     * @author 老张
     */
    public static boolean startCheckVideoSnap(String picUrl) {
        ImageSyncScanRequest imageSyncScanRequest = new ImageSyncScanRequest();
        // 指定API返回格式。
        imageSyncScanRequest.setAcceptFormat(FormatType.JSON);
        // 指定请求方法。
        imageSyncScanRequest.setMethod(MethodType.POST);
        imageSyncScanRequest.setEncoding("utf-8");
        // 支持HTTP和HTTPS。
        imageSyncScanRequest.setProtocol(ProtocolType.HTTP);

        JSONObject httpBody = new JSONObject();
        /**
         * 设置要检测的风险场景。计费依据此处传递的场景计算。 一次请求中可以同时检测多张图片，每张图片可以同时检测多个风险场景，计费按照场景计算。
         * 例如，检测2张图片，场景传递porn和terrorism，计费会按照2张图片鉴黄，2张图片暴恐检测计算。 porn：表示鉴黄场景。
         */
        httpBody.put("scenes", Arrays.asList("porn"));

        /**
         * 设置待检测图片。一张图片对应一个task。 多张图片同时检测时，处理的时间由最后一个处理完的图片决定。
         * 通常情况下批量检测的平均响应时间比单张检测的要长。一次批量提交的图片数越多，响应时间被拉长的概率越高。 这里以单张图片检测作为示例, 如果是批量图片检测，请自行构建多个task。
         */
        JSONObject task = new JSONObject();
        task.put("dataId", UUID.randomUUID().toString());

        // 设置图片链接。URL中有特殊字符，需要对URL进行encode编码。
        task.put("url", picUrl);
        task.put("time", new Date());
        httpBody.put("tasks", Arrays.asList(task));

        imageSyncScanRequest.setHttpContent(
                org.apache.commons.codec.binary.StringUtils.getBytesUtf8(httpBody.toStringPretty()),
                "UTF-8",
                FormatType.JSON);
        /** 请设置超时时间。服务端全链路处理超时时间为10秒，请做相应设置。 如果您设置的ReadTimeout小于服务端处理的时间，程序中会获得一个ReadTimeout异常。 */
        imageSyncScanRequest.setConnectTimeout(3000);
        imageSyncScanRequest.setReadTimeout(10000);
        HttpResponse httpResponse = null;
        try {
            httpResponse = IACS_CLIENT.doAction(imageSyncScanRequest);
        } catch (Exception e) {
            log.error("鉴黄失败检查配置", e);
        }
        // 服务端接收到请求，完成处理后返回的结果。
        if (httpResponse != null && httpResponse.isSuccess()) {
            JSONObject scrResponse =
                    JSONUtil.parseObj(
                            org.apache.commons.codec.binary.StringUtils.newStringUtf8(
                                    httpResponse.getHttpContent()));

            log.info("识别结果:{}", scrResponse.toStringPretty());
            int requestCode = scrResponse.getInt("code");
            // 每一张图片的检测结果。
            JSONArray taskResults = scrResponse.getJSONArray("data");
            if (200 == requestCode) {
                for (Object taskResult : taskResults) {
                    // 单张图片的处理结果。
                    int taskCode = ((JSONObject) taskResult).getInt("code");
                    // 图片对应检测场景的处理结果。如果是多个场景，则会有每个场景的结果。
                    JSONArray sceneResults = ((JSONObject) taskResult).getJSONArray("results");
                    if (200 == taskCode) {
                        for (Object sceneResult : sceneResults) {
                            String scene = ((JSONObject) sceneResult).getStr("scene");
                            String suggestion = ((JSONObject) sceneResult).getStr("suggestion");
                            // 根据scene和suggestion做相关处理。
                            // 根据不同的suggestion结果做业务上的不同处理。例如，将违规数据删除等。
                            log.info(
                                    "scene = ["
                                            + scene
                                            + "]"
                                            + "suggestion = ["
                                            + suggestion
                                            + "]");
                            return "block".equals(suggestion);
                        }
                    } else {
                        // 单张图片处理失败, 原因视具体的情况详细分析。
                        log.error("单图鉴黄处理失败:{}", scrResponse.toStringPretty());
                    }
                }
            } else {
                log.error("所有鉴黄处理失败:{}", scrResponse.toStringPretty());
            }
        }
        return false;
    }

    public static String getRecordUrl(String roomNum, String taskId) {
        // 录制的房间号，如果这里 RoomId 如果是字符串房间号，我们会对房间号先做 base64 操作，再把 base64 后的字符串中符号'/'替换成 '-'
        // (中划线)，符号'='替换成 '.'
        String encode =
                cn.hutool.core.codec.Base64.encode(roomNum).replace("/", "-").replace("=", ".");

        return TencentRTCUtils.RECORD_BASE_PATH
                + "/"
                + taskId
                + "/"
                + TRTC.getAppid()
                + "_"
                + encode
                + ".m3u8";
    }

    /**
     * 成功开启录制后，可以使用此接口来停止录制任务。停止录制成功后不代表文件全部传输完成，如果未完成后台将会继续上传文件，成功后通过事件回调通知客户文件全部传输完成状态。
     *
     * @return DeleteCloudRecordingResponse
     * @throws TencentCloudSDKException
     */
    public static boolean stopRecording(String taskId) {
        try {
            DeleteCloudRecordingRequest req = new DeleteCloudRecordingRequest();

            req.setSdkAppId(TRTC.getAppid());
            req.setTaskId(taskId);
            TRTC_CLIENT.DeleteCloudRecording(req);
            return true;
        } catch (Exception e) {
            log.error("停止录音失败", e);
            return false;
        }
    }

    /**
     * 接口说明： 启动云端录制功能，完成房间内的音视频录制，并上传到指定的云存储。您可以通过此 API 接口把TRTC 房间中的每一路音视频流做单独的录制又或者多路视频画面合流混成一路。
     *
     * <p>您可以通过此接口实现如下目标： 指定订阅流参数（RecordParams）来指定需要录制的主播的黑名单或者白名单。
     * 指定录制存储参数（StorageParams）来指定上传到您希望的云存储，目前支持腾讯云（云点播VOD、对象存储COS）和第三方AWS
     * 指定合流模式下的音视频转码详细参数（MixTranscodeParams），包括视频分辨率、视频码率、视频帧率、以及声音质量等
     * 指定合流模式各路画面的位置和布局或者也可以指定自动模板的方式来配置。
     *
     * <p>关键名词： 单流录制：分别录制房间的订阅UserId的音频和视频，录制服务会实时将录制文件上传至您指定的云存储。
     * 合流录制：将房间内订阅UserId的音视频混录成一个视频文件，并将录制文件上传至您指定的云存储。（录制结束后可前往云点播控制台https://console.cloud.tencent.com/vod/media
     * 或 对象存储COS控制台https://console.cloud.tencent.com/cos/bucket查看文件）。
     *
     * @return CreateCloudRecordingResponse
     * @throws TencentCloudSDKException
     */
    public static String startRecording(String roomId) {
        CreateCloudRecordingRequest req = new CreateCloudRecordingRequest();
        req.setSdkAppId(TRTC.getAppid());
        req.setRoomId(roomId);
        req.setUserId(roomId);
        req.setUserSig(TencentRTCUtils.genUserSig(roomId, 60));

        RecordParams recordParams = new RecordParams();
        //        录制模式：
        //        1：单流录制，分别录制房间的订阅UserId的音频和视频，将录制文件上传至云存储；
        //        2：合流录制，将房间内订阅UserId的音视频混录成一个音视频文件，将录制文件上传至云存储；
        //        示例值：1
        recordParams.setRecordMode(2L);
        //        房间内持续没有用户（主播）上行推流的状态超过MaxIdleTime的时长，自动停止录制，单位：秒。默认值为 30 秒，该值需大于等于 5秒，且小于等于
        // 86400秒(24小时)。
        //        示例值：30
        recordParams.setMaxIdleTime(5L);
        //        录制的媒体流类型：
        //        0：录制音频+视频流（默认）;
        //        1：仅录制音频流；
        //        2：仅录制视频流，
        //        示例值：0
        recordParams.setStreamType(1L);
        //        输出文件的格式（存储至COS等第三方存储时有效）。
        //        0：(默认)输出文件为hls格式。
        //        1：输出文件格式为hls+mp4。
        //        2：输出文件格式为hls+aac 。
        //        3：输出文件格式为mp4。
        //        4：输出文件格式为aac。
        recordParams.setOutputFormat(0L);

        req.setRecordParams(recordParams);

        // 布局
        MixLayoutParams mixLayoutParams = new MixLayoutParams();
        mixLayoutParams.setMixLayoutMode(3L);
        req.setMixLayoutParams(mixLayoutParams);

        StorageParams storageParams = new StorageParams();

        CloudStorage cloudStorage = new CloudStorage();
        //        腾讯云对象存储COS以及第三方云存储账号信息
        //        0：腾讯云对象存储 COS
        //        1：AWS
        // 【注意】目前第三方云存储仅支持AWS，更多第三方云存储陆续支持中
        //        示例值：0
        //        示例值：0
        cloudStorage.setVendor(0L);
        cloudStorage.setRegion(COS.getRegion());
        cloudStorage.setBucket(COS.getBucket());
        cloudStorage.setAccessKey(COS.getAccesskey());
        cloudStorage.setSecretKey(COS.getSecretkey());
        String[] prefix = {RECORD_BASE_PATH};

        cloudStorage.setFileNamePrefix(prefix);
        storageParams.setCloudStorage(cloudStorage);

        req.setStorageParams(storageParams);
        //        0: 字符串类型的RoomId
        //        1: 32位整型的RoomId（默认)
        req.setRoomIdType(0L);

        req.setSkipSign(false);
        try {
            CreateCloudRecordingResponse res = TRTC_CLIENT.CreateCloudRecording(req);
            log.info(JSONUtil.toJsonPrettyStr(res));
            return res.getTaskId();
        } catch (Exception e) {
            log.error("开始录音失败", e);
            throw AppServiceException.paramException("RTC网络异常,请稍后再试");
        }
    }

    /** 解散房间 */
    public static void dismissRoom(String roomNum) {
        // 实例化一个请求对象,每个接口都会对应一个request对象
        DismissRoomByStrRoomIdRequest req = new DismissRoomByStrRoomIdRequest();
        req.setRoomId(roomNum);
        req.setSdkAppId(TRTC.getAppid());
        // 返回的resp是一个DismissRoomByStrRoomIdResponse的实例，与请求对象对应

        // 输出json格式的字符串回包
        DismissRoomByStrRoomIdResponse resp = null;
        try {
            resp = TRTC_CLIENT.DismissRoomByStrRoomId(req);
            log.info("解散操作响应:{}", AbstractModel.toJsonString(resp));
        } catch (TencentCloudSDKException e) {
            log.error(
                    "解散房间异常,房间号:{},异常code:{},请求ID:{},响应JSON:{}",
                    roomNum,
                    e.getErrorCode(),
                    e.getRequestId(),
                    JSONUtil.toJsonPrettyStr(resp));
        }
    }

    /**
     * 【功能说明】用于签发 TRTC 和 IM 服务中必须要使用的 UserSig 鉴权票据
     *
     * <p>【参数说明】
     *
     * @param userid - 用户id，限制长度为32字节，只允许包含大小写英文字母（a-zA-Z）、数字（0-9）及下划线和连词符。
     * @param expire - UserSig 票据的过期时间，单位是秒，比如 86400 代表生成的 UserSig 票据在一天后就无法再使用了。
     * @return usersig -生成的签名
     */

    /**
     * Function: Used to issue UserSig that is required by the TRTC and IM services.
     *
     * <p>Parameter description:
     *
     * @param userid - User ID. The value can be up to 32 bytes in length and contain letters (a-z
     *     and A-Z), digits (0-9), underscores (_), and hyphens (-).
     * @param expire - UserSig expiration time, in seconds. For example, 86400 indicates that the
     *     generated UserSig will expire one day after being generated.
     * @return usersig - Generated signature.
     */
    public static String genUserSig(String userid, long expire) {
        return genUserSig(userid, expire, null);
    }

    /**
     * 【功能说明】 用于签发 TRTC 进房参数中可选的 PrivateMapKey 权限票据。 PrivateMapKey 需要跟 UserSig 一起使用，但 PrivateMapKey
     * 比 UserSig 有更强的权限控制能力： - UserSig 只能控制某个 UserID 有无使用 TRTC 服务的权限，只要 UserSig 正确，其对应的 UserID
     * 可以进出任意房间。 - PrivateMapKey 则是将 UserID 的权限控制的更加严格，包括能不能进入某个房间，能不能在该房间里上行音视频等等。 如果要开启
     * PrivateMapKey 严格权限位校验，需要在【实时音视频控制台】/【应用管理】/【应用信息】中打开“启动权限密钥”开关。
     *
     * <p>【参数说明】
     *
     * @param userid - 用户id，限制长度为32字节，只允许包含大小写英文字母（a-zA-Z）、数字（0-9）及下划线和连词符。
     * @param expire - PrivateMapKey 票据的过期时间，单位是秒，比如 86400 生成的 PrivateMapKey 票据在一天后就无法再使用了。
     * @param roomid - 房间号，用于指定该 userid 可以进入的房间号
     * @param privilegeMap - 权限位，使用了一个字节中的 8 个比特位，分别代表八个具体的功能权限开关： - 第 1 位：0000 0001 = 1，创建房间的权限 - 第
     *     2 位：0000 0010 = 2，加入房间的权限 - 第 3 位：0000 0100 = 4，发送语音的权限 - 第 4 位：0000 1000 = 8，接收语音的权限 - 第
     *     5 位：0001 0000 = 16，发送视频的权限 - 第 6 位：0010 0000 = 32，接收视频的权限 - 第 7 位：0100 0000 =
     *     64，发送辅路（也就是屏幕分享）视频的权限 - 第 8 位：1000 0000 = 200，接收辅路（也就是屏幕分享）视频的权限 - privilegeMap == 1111
     *     1111 == 255 代表该 userid 在该 roomid 房间内的所有功能权限。 - privilegeMap == 0010 1010 == 42 代表该 userid
     *     拥有加入房间和接收音视频数据的权限，但不具备其他权限。
     * @return usersig - 生成带userbuf的签名
     */

    /**
     * Function: Used to issue PrivateMapKey that is optional for room entry. PrivateMapKey must be
     * used together with UserSig but with more powerful permission control capabilities. - UserSig
     * can only control whether a UserID has permission to use the TRTC service. As long as the
     * UserSig is correct, the user with the corresponding UserID can enter or leave any room. -
     * PrivateMapKey specifies more stringent permissions for a UserID, including whether the UserID
     * can be used to enter a specific room and perform audio/video upstreaming in the room. To
     * enable stringent PrivateMapKey permission bit verification, you need to enable permission key
     * in TRTC console > Application Management > Application Info.
     *
     * <p>Parameter description:
     *
     * @param userid - User ID. The value can be up to 32 bytes in length and contain letters (a-z
     *     and A-Z), digits (0-9), underscores (_), and hyphens (-).
     * @param roomid - ID of the room to which the specified UserID can enter.
     * @param expire - PrivateMapKey expiration time, in seconds. For example, 86400 indicates that
     *     the generated PrivateMapKey will expire one day after being generated.
     * @param privilegeMap - Permission bits. Eight bits in the same byte are used as the permission
     *     switches of eight specific features: - Bit 1: 0000 0001 = 1, permission for room creation
     *     - Bit 2: 0000 0010 = 2, permission for room entry - Bit 3: 0000 0100 = 4, permission for
     *     audio sending - Bit 4: 0000 1000 = 8, permission for audio receiving - Bit 5: 0001 0000 =
     *     16, permission for video sending - Bit 6: 0010 0000 = 32, permission for video receiving
     *     - Bit 7: 0100 0000 = 64, permission for substream video sending (screen sharing) - Bit 8:
     *     1000 0000 = 200, permission for substream video receiving (screen sharing) - privilegeMap
     *     == 1111 1111 == 255: Indicates that the UserID has all feature permissions of the room
     *     specified by roomid. - privilegeMap == 0010 1010 == 42: Indicates that the UserID has
     *     only the permissions to enter the room and receive audio/video data.
     * @return usersig - Generate signature with userbuf
     */
    private String genPrivateMapKey(String userid, long expire, long roomid, long privilegeMap) {
        byte[] userbuf = genUserBuf(userid, roomid, expire, privilegeMap, 0, ""); // 生成userbuf
        return genUserSig(userid, expire, userbuf);
    }

    /**
     * 【功能说明】 用于签发 TRTC 进房参数中可选的 PrivateMapKey 权限票据。 PrivateMapKey 需要跟 UserSig 一起使用，但 PrivateMapKey
     * 比 UserSig 有更强的权限控制能力： - UserSig 只能控制某个 UserID 有无使用 TRTC 服务的权限，只要 UserSig 正确，其对应的 UserID
     * 可以进出任意房间。 - PrivateMapKey 则是将 UserID 的权限控制的更加严格，包括能不能进入某个房间，能不能在该房间里上行音视频等等。 如果要开启
     * PrivateMapKey 严格权限位校验，需要在【实时音视频控制台】/【应用管理】/【应用信息】中打开“启动权限密钥”开关。
     *
     * <p>【参数说明】
     *
     * @param userid - 用户id，限制长度为32字节，只允许包含大小写英文字母（a-zA-Z）、数字（0-9）及下划线和连词符。
     * @param expire - PrivateMapKey 票据的过期时间，单位是秒，比如 86400 生成的 PrivateMapKey 票据在一天后就无法再使用了。
     * @param roomstr - 字符串房间号，用于指定该 userid 可以进入的房间号
     * @param privilegeMap - 权限位，使用了一个字节中的 8 个比特位，分别代表八个具体的功能权限开关： - 第 1 位：0000 0001 = 1，创建房间的权限 - 第
     *     2 位：0000 0010 = 2，加入房间的权限 - 第 3 位：0000 0100 = 4，发送语音的权限 - 第 4 位：0000 1000 = 8，接收语音的权限 - 第
     *     5 位：0001 0000 = 16，发送视频的权限 - 第 6 位：0010 0000 = 32，接收视频的权限 - 第 7 位：0100 0000 =
     *     64，发送辅路（也就是屏幕分享）视频的权限 - 第 8 位：1000 0000 = 200，接收辅路（也就是屏幕分享）视频的权限 - privilegeMap == 1111
     *     1111 == 255 代表该 userid 在该 roomid 房间内的所有功能权限。 - privilegeMap == 0010 1010 == 42 代表该 userid
     *     拥有加入房间和接收音视频数据的权限，但不具备其他权限。
     * @return usersig - 生成带userbuf的签名
     */

    /**
     * Function: Used to issue PrivateMapKey that is optional for room entry. PrivateMapKey must be
     * used together with UserSig but with more powerful permission control capabilities. - UserSig
     * can only control whether a UserID has permission to use the TRTC service. As long as the
     * UserSig is correct, the user with the corresponding UserID can enter or leave any room. -
     * PrivateMapKey specifies more stringent permissions for a UserID, including whether the UserID
     * can be used to enter a specific room and perform audio/video upstreaming in the room. To
     * enable stringent PrivateMapKey permission bit verification, you need to enable permission key
     * in TRTC console > Application Management > Application Info.
     *
     * <p>Parameter description:
     *
     * @param userid - User ID. The value can be up to 32 bytes in length and contain letters (a-z
     *     and A-Z), digits (0-9), underscores (_), and hyphens (-).
     * @param - ID of the room to which the specified UserID can enter.
     * @param expire - PrivateMapKey expiration time, in seconds. For example, 86400 indicates that
     *     the generated PrivateMapKey will expire one day after being generated.
     * @param privilegeMap - Permission bits. Eight bits in the same byte are used as the permission
     *     switches of eight specific features: - Bit 1: 0000 0001 = 1, permission for room creation
     *     - Bit 2: 0000 0010 = 2, permission for room entry - Bit 3: 0000 0100 = 4, permission for
     *     audio sending - Bit 4: 0000 1000 = 8, permission for audio receiving - Bit 5: 0001 0000 =
     *     16, permission for video sending - Bit 6: 0010 0000 = 32, permission for video receiving
     *     - Bit 7: 0100 0000 = 64, permission for substream video sending (screen sharing) - Bit 8:
     *     1000 0000 = 200, permission for substream video receiving (screen sharing) - privilegeMap
     *     == 1111 1111 == 255: Indicates that the UserID has all feature permissions of the room
     *     specified by roomid. - privilegeMap == 0010 1010 == 42: Indicates that the UserID has
     *     only the permissions to enter the room and receive audio/video data.
     * @return usersig - Generate signature with userbuf
     */
    private String genPrivateMapKeyWithStringRoomID(
            String userid, long expire, String roomstr, long privilegeMap) {
        byte[] userbuf = genUserBuf(userid, 0, expire, privilegeMap, 0, roomstr); // 生成userbuf
        return genUserSig(userid, expire, userbuf);
    }

    private static String hmacsha256(
            String identifier, long currTime, long expire, String base64Userbuf) {
        String contentToBeSigned =
                "TLS.identifier:"
                        + identifier
                        + "\n"
                        + "TLS.sdkappid:"
                        + TRTC.getAppid()
                        + "\n"
                        + "TLS.time:"
                        + currTime
                        + "\n"
                        + "TLS.expire:"
                        + expire
                        + "\n";
        if (null != base64Userbuf) {
            contentToBeSigned += "TLS.userbuf:" + base64Userbuf + "\n";
        }
        try {
            byte[] byteKey = TRTC.getAppkey().getBytes(StandardCharsets.UTF_8);
            Mac hmac = Mac.getInstance("HmacSHA256");
            SecretKeySpec keySpec = new SecretKeySpec(byteKey, "HmacSHA256");
            hmac.init(keySpec);
            byte[] byteSig = hmac.doFinal(contentToBeSigned.getBytes(StandardCharsets.UTF_8));
            return (Base64.getEncoder().encodeToString(byteSig)).replaceAll("\\s*", "");
        } catch (NoSuchAlgorithmException | InvalidKeyException e) {
            return "";
        }
    }

    private static String genUserSig(String userid, long expire, byte[] userbuf) {

        long currTime = System.currentTimeMillis() / 1000;

        JSONObject sigDoc = new JSONObject();
        sigDoc.put("TLS.ver", "2.0");
        sigDoc.put("TLS.identifier", userid);
        sigDoc.put("TLS.sdkappid", TRTC.getAppid());
        sigDoc.put("TLS.expire", expire);
        sigDoc.put("TLS.time", currTime);

        String base64UserBuf = null;
        if (null != userbuf) {
            base64UserBuf = Base64.getEncoder().encodeToString(userbuf).replaceAll("\\s*", "");
            sigDoc.put("TLS.userbuf", base64UserBuf);
        }
        String sig = hmacsha256(userid, currTime, expire, base64UserBuf);
        if (sig.length() == 0) {
            return "";
        }
        sigDoc.put("TLS.sig", sig);
        Deflater compressor = new Deflater();
        compressor.setInput(sigDoc.toString().getBytes(StandardCharsets.UTF_8));
        compressor.finish();
        byte[] compressedBytes = new byte[2048];
        int compressedBytesLength = compressor.deflate(compressedBytes);
        compressor.end();
        return (new String(
                        Base64URL.base64EncodeUrl(
                                Arrays.copyOfRange(compressedBytes, 0, compressedBytesLength))))
                .replaceAll("\\s*", "");
    }

    private byte[] genUserBuf(
            String account,
            long dwAuthID,
            long dwExpTime,
            long dwPrivilegeMap,
            long dwAccountType,
            String RoomStr) {
        int accountLength = account.length();
        int roomStrLength = RoomStr.length();
        int offset = 0;
        int bufLength = 1 + 2 + accountLength + 20;
        if (roomStrLength > 0) {
            bufLength = bufLength + 2 + roomStrLength;
        }
        byte[] userbuf = new byte[bufLength];

        // cVer
        if (roomStrLength > 0) {
            userbuf[offset++] = 1;
        } else {
            userbuf[offset++] = 0;
        }
        // wAccountLen
        userbuf[offset++] = (byte) ((accountLength & 0xFF00) >> 8);
        userbuf[offset++] = (byte) (accountLength & 0x00FF);
        // account
        for (; offset < 3 + accountLength; ++offset) {
            userbuf[offset] = (byte) account.charAt(offset - 3);
        }
        // dwSdkAppid
        userbuf[offset++] = (byte) ((TRTC.getAppid() & 0xFF000000) >> 24);
        userbuf[offset++] = (byte) ((TRTC.getAppid() & 0x00FF0000) >> 16);
        userbuf[offset++] = (byte) ((TRTC.getAppid() & 0x0000FF00) >> 8);
        userbuf[offset++] = (byte) (TRTC.getAppid() & 0x000000FF);
        // dwAuthId,房间号
        // dwAuthId, room number
        userbuf[offset++] = (byte) ((dwAuthID & 0xFF000000) >> 24);
        userbuf[offset++] = (byte) ((dwAuthID & 0x00FF0000) >> 16);
        userbuf[offset++] = (byte) ((dwAuthID & 0x0000FF00) >> 8);
        userbuf[offset++] = (byte) (dwAuthID & 0x000000FF);
        // expire，过期时间,当前时间 + 有效期（单位：秒）
        // expire,Expiration time, current time + validity period (unit: seconds)
        long currTime = System.currentTimeMillis() / 1000;
        long expire = currTime + dwExpTime;
        userbuf[offset++] = (byte) ((expire & 0xFF000000) >> 24);
        userbuf[offset++] = (byte) ((expire & 0x00FF0000) >> 16);
        userbuf[offset++] = (byte) ((expire & 0x0000FF00) >> 8);
        userbuf[offset++] = (byte) (expire & 0x000000FF);
        // dwPrivilegeMap，权限位
        // dwPrivilegeMap，Permission bits
        userbuf[offset++] = (byte) ((dwPrivilegeMap & 0xFF000000) >> 24);
        userbuf[offset++] = (byte) ((dwPrivilegeMap & 0x00FF0000) >> 16);
        userbuf[offset++] = (byte) ((dwPrivilegeMap & 0x0000FF00) >> 8);
        userbuf[offset++] = (byte) (dwPrivilegeMap & 0x000000FF);
        // dwAccountType，账户类型
        // dwAccountType，account type
        userbuf[offset++] = (byte) ((dwAccountType & 0xFF000000) >> 24);
        userbuf[offset++] = (byte) ((dwAccountType & 0x00FF0000) >> 16);
        userbuf[offset++] = (byte) ((dwAccountType & 0x0000FF00) >> 8);
        userbuf[offset++] = (byte) (dwAccountType & 0x000000FF);
        if (roomStrLength > 0) {
            // roomStrLen
            userbuf[offset++] = (byte) ((roomStrLength & 0xFF00) >> 8);
            userbuf[offset++] = (byte) (roomStrLength & 0x00FF);

            // roomStr
            for (; offset < bufLength; ++offset) {
                userbuf[offset] = (byte) RoomStr.charAt(offset - (bufLength - roomStrLength));
            }
        }
        return userbuf;
    }

    private static class Base64URL {
        public static byte[] base64EncodeUrl(byte[] input) {
            byte[] base64 = Base64.getEncoder().encode(input);
            for (int i = 0; i < base64.length; ++i)
                switch (base64[i]) {
                    case '+':
                        base64[i] = '*';
                        break;
                    case '/':
                        base64[i] = '-';
                        break;
                    case '=':
                        base64[i] = '_';
                        break;
                    default:
                        break;
                }
            return base64;
        }
    }

    private static String toHexString(byte[] bytes) {
        Formatter formatter = new Formatter();

        for (byte b : bytes) {
            formatter.format("%02x", b);
        }

        return formatter.toString();
    }

    @SneakyThrows
    public static String calculateRFC2104HMAC(String data, String key) {
        SecretKeySpec signingKey = new SecretKeySpec(key.getBytes(), HMAC_SHA256_ALGORITHM);
        Mac mac = Mac.getInstance(HMAC_SHA256_ALGORITHM);
        mac.init(signingKey);
        return toHexString(mac.doFinal(data.getBytes()));
    }

    @Data
    @ToString
    public static class Trtc {
        // https://console.cloud.tencent.com/trtc 应用详情处获取,这个参数用来生成userSignQ 前端调起视频
        // 应用id
        private Long appid;
        // app_key
        private String appkey;
        // https://console.cloud.tencent.com/cam/capi 这个是服务端Api的密钥,可以用来踢人,解散房间
        private String secretId;
        private String secretKey;
        private String endpoint;
        private String region;
    }

    @Data
    @ToString
    public static class Cos {
        private String region;
        private String bucket;
        private String accesskey;
        private String secretkey;
    }

    @Data
    @ToString
    public static class SnapCheck {
        private String endpoint;
        private String region;
        private String AccessKeyId;
        private String AccessKeySecret;
    }

    @Data
    @ToString
    public static class Yitu {
        private String domain;
        private String accessId;
        private String accessKey;
        private String appId;
        private String callback;
    }
}
